标签

spring

工具

字数

734 字

阅读时间

4 分钟

验证工具类

import com.commnetsoft.commons.utils.StringUtils;

import java.util.*;

/**
 * 验证工具类
 * @author sunwen
 * @since 2019/7/18
 */
public class ValidHelper {

    private static Map<String, Constraint> constraints = new HashMap<>();

    static {
        register(new NotEmpty());
        register(new Length());
        register(new Range());
        register(new Unique());
    }

    /**
     * 注册约束,注册成功返回true
     * @author sunwen
     * @since 2019/7/18
     */
    public static boolean register(Constraint constraint){
        if(constraint != null){
            String name = constraint.name();
            if(!constraints.containsKey(name)){
                constraints.put(name, constraint);
                return true;
            }
        }
        return true;
    }

    /**
     * 解析验证器
     * @author sunwen
     * @since 2019/7/18
     */
    public static Validator parse(String expression) throws Exception{
        String name = null;
        String args = null;
        if (expression.contains("(")){
            String[] split = expression.split("(?=\\()");
            if (split.length == 2) {
                name = split[0].trim();
                args = split[1].trim();
                String removeStart = StringUtils.removeStart(args, "(");
                args = StringUtils.removeEnd(removeStart, ")");
            }
        }else{
            name = expression;
        }
        Constraint c = constraints.get(name);
        if(c != null){
            //TODO 相同参数可以优化从缓存中读取
            return c.create(args);
        }
        throw new Exception("约束未定义");
    }

    public static List<Validator> batchParse(String expression) throws Exception{
        if (StringUtils.isEmpty(expression)) {
            return null;
        }
        expression = StringUtils.removeStart(expression, " ");
        expression = StringUtils.removeEnd(expression, " ");
        String[] split = expression.split(" +(?=[^\\)]+(\\(|$))|(?<=\\))");
        List<Validator> validatorList = new ArrayList<>();
        for(String exp : split){
            validatorList.add(parse(exp));
        }
        return validatorList;
    }



}

接口

/**
 * 约束接口，用于创建约束验证器，生成约束表达式
 * @author sunwen
 * @since 2019/7/18
 */
public interface Constraint<T extends Validator> {

    /**
     * 约束名称
     * @author sunwen
     * @since 2019/7/18
     */
    String name();

    /**
     * 中文名
     * @author wuzm
     * @since 2020/1/3
     */
    String chName();

    /**
     * 根据字符串参数创建约束验证器，
     * @param args 字符串参数，多个参数一般约定已“,”分隔
     * @author sunwen
     * @since 2019/7/18
     */
    T create(String args) throws Exception;

    /**
     * 根据多个参数创建约束验证器
     * @author sunwen
     * @since 2019/7/18
     */
    T create(Object... args) throws Exception;

    /**
     * 根据验证器创建表达式
     * @author sunwen
     * @since 2019/7/18
     */
    String express(T validator);

}

import com.commnetsoft.commons.Result;

import java.util.Map;

/**
 * 验证器接口
 * @author sunwen
 * @since 2019/7/18
 */
public interface Validator {

    /**
     * 验证数据
     * @param value 验证的数据
     * @param context 验证上下文数据
     * @author sunwen
     * @since 2019/7/18
     */
    Result<Void> validate(Object value, Map<String, Object> context);
}

实现

/**
 * 数据唯一验证
 * @author sunwen
 * @since 2019/7/26
 */
public class Unique implements Constraint<Validator> {

    @Override
    public String name() {
        return "unique";
    }

    @Override
    public String chName() {
        return "唯一性";
    }

    @Override
    public Validator create(String args) throws Exception {
        return UniqueValidator.load();
    }

    @Override
    public Validator create(Object... args) throws Exception {
        return UniqueValidator.load();
    }

    @Override
    public String express(Validator validator) {
        return name();
    }

}

import com.commnetsoft.core.CoreConstant;
import com.commnetsoft.core.utils.ClassScaner;

import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * 唯一性验证，自动加载项目中的实现类
 * @author sunwen
 * @since 2020/7/9
 */
public abstract class UniqueValidator implements Validator {

    private static UniqueValidator validator;
    private static final AtomicBoolean loaded = new AtomicBoolean();

    public static UniqueValidator load() throws Exception{
        if(!loaded.get()){
            synchronized (loaded){
                List<Class<? extends UniqueValidator>> list = ClassScaner.scan(CoreConstant.Package.BASE, UniqueValidator.class);
                if(list.size() > 0){
                    validator = list.get(0).newInstance();
                }
                loaded.set(true);
            }
        }
        if(validator == null){
            throw new Exception("unique约束找不到Validator实现类");
        }
        return validator;
    }

}

验证错误

import com.alibaba.fastjson.annotation.JSONType;
import com.commnetsoft.core.IErrorConstant;
import com.commnetsoft.ConstantEnum;

@JSONType(serializeEnumAsJavaBean = true)
@ConstantEnum(value = "验证错误码", namespace = "error", fixed = true)
public enum  ValidateError implements IErrorConstant {

    type_error("数据类型不正确"),
    not_empty("值不能为空"),
    out_of_range("值超出范围"),
    length_limit("长度不在范围内"),
    unique_limit("值已存在"),
    ;

    private String msg;

    ValidateError(){}

    ValidateError(String msg){
            this.msg = msg;
        }

    @Override
    public void setMessage(String message) {
        this.msg = message;
    }

    @Override
    public String getMessage() {
        return msg;
    }

}